Skip Headers

Oracle® Database Java Developer's Guide 10g Release 2 (10.2) Part Number B14187-01 |
Home | Book List | Contents | Index | Master Index | Feedback

Previous | Next
| View PDF

# 1 Introduction to Java in Oracle Database

Oracle Database provides support for developing, storing, and deploying Java applications. This chapter introduces the Java language to Oracle PL/SQL developers, who are accustomed to developing server-side applications that are integrated with SQL data. You can develop server-side Java applications that take advantage of the scalability and performance of Oracle Database.

This chapter contains the following sections:

- Overview of Java

- Using Java in Oracle Database

- The Oracle JVM

- Main Components of the Oracle JVM

- Java Application Strategy of Oracle

- Desupport of J2EE Technologies in the Oracle Database

- Memory Model for Dedicated Mode Sessions

- What's New in this Release?

## 1.1 Overview of Java

Java has emerged as the object-oriented programming language of choice. Some of the important concepts of Java include:

- Java virtual machine (JVM), which provides the fundamental basis for platform independence

- Automated storage management techniques, such as garbage collection

- Language syntax that is similar to that of the C language

The result is a language that is object-oriented and efficient for application programming.

This section covers the following topics:

- Java and Object-Oriented Programming Terminology

- Key Features of the Java Language

- The JVM

- Java Class Hierarchy

### 1.1.1 Java and Object-Oriented Programming Terminology

The following terms are common in Java application development in the Oracle Database environment:

- Classes

- Objects

- Interfaces

- Encapsulation

- Inheritance

- Polymorphism

#### 1.1.1.1 C lasses

All object-oriented programming languages support the concept of a class. As with a table definition, a class provides a template for objects that share common characteristics. Each class can contain the following:

- Attrib utes

  Attributes are variables that are present in each object, or instance, of a particular class. Attributes within an instance are known as fields. Instance fields are analogous to the fields of a relational table row. The class defines the variables and the type of each variable. You can declare variables in Java as `static` and `public`, `private`, `protected`, or default access.

  Variables of a class that are declared as `static` are global and common to all instances of that class. Variables that are not declared as `static` are created within each instance of the class.

  The `public`, `private`, `protected`, and default access modifiers define the scope of the variable in the application. The Java Language Specification (JLS) defines the rules of visibility of data for all variables. These rules define under what circumstances you can access the data in these variables.

  In the example illustrated in Figure 1-1, the employee identifier is defined as `private`, indicating that other objects cannot access this attribute directly. In the example, objects can access the `id` attribute by calling the `getId()` method.

- Meth ods

  Methods are blocks of code that perform specific tasks or actions. You can call the methods on an instance of the class. You can also call methods that are inherited by the class. Methods provide a way for instances to interact with other instances and the application. Similar to attributes, methods can be declared as `public`, `private`, `protected`, or default access.

#### 1.1.1.2 Objects

A class needs to be instantiated before you can use the instance variables or attributes and methods. An object is an instance of a class and is analogous to a relational table row. The instance contains the attributes, which are known as its data or state, and the methods defined in the class.

Figure 1-1 shows an example of an `Employee` class defined with two attributes, `id`, which is the employee identifier, and `lastName`, which is the last name of the employee, and the `getId()` and `setId(String anId)` methods. The `id` attribute and the `getId()` method are `private`, and the `lastName` attribute and the `setId(String anId)` method are `public`.

Figure 1-1 Classes and Instances

Description of the illustration 01intra.gif

When you create an instance, the attributes store individual and private information relevant only to the employee. That is, the information contained within an employee instance is known only to that particular employee. The example in Figure 1-1 shows two instances of the `Employee` class, one for the employee Smith and one for Jones. Each instance contains information relevant to the individual employee.

#### 1.1.1.3 Interf aces

Java supports only single inheritance, that is, each class can inherit attributes and methods of only one class. If you need to inherit properties from more than one source, then Java provides the concept of interfaces, which is equivalent to multiple inheritance. Interfaces are similar to classes. However, they define only the signature of the methods and not their implementations. The methods that are declared in the interface are implemented in the classes. Multiple inheritance occurs when a class implements multiple interfaces.

#### 1.1.1.4 Encapsulation

Encapsulation describes the ability of an object to hide its data and methods from the rest of the world and is one of the fundamental principles of object-oriented programming. In Java, a class encapsulates the attributes, which hold the state of an object, and the methods, which define the actions of the object. Encapsulation enables you to write reusable programs. It also enables you to restrict access only to those features of an object that are declared `public`. All other attributes and methods are `private` and can be used for internal object processing.

In the example illustrated in Figure 1-1, the `id` attribute is `private` and access to it is restricted to the object that defines it. Other objects can access this attribute using the `getId()` method. Using encapsulation, you can deny access to the `id` attribute either by declaring the `getId()` method as `private` or by not defining the `getId()` method.

#### 1.1.1.5 Inheri tance

Inheritance is an important feature of object-oriented programming languages. It enables classes to acquire properties of other classes. The class that inherits the properties is called a child class or subclass and the class from which the properties are inherited is called a parent class or superclass. This feature also helps in reusing an already defined code.

In the example illustrated in Figure 1-1, you can create a `FullTimeEmployee` class that inherits the properties of the `Employee` class. The properties inherited depend on the access modifiers declared for each attribute and method of the superclass.

#### 1.1.1.6 Poly morphism

Polymorphism is the ability for different objects to respond differently to the same message. In object-oriented programming languages, you can define one or more methods with the same name. These methods can perform different actions and return different values.

In the example in Figure 1-1, assume that the different types of employees must be able to respond with their compensation to date. Compensation is computed differently for different kinds of employees:

- Full-time employees are eligible for a bonus.

- Non-exempt employees get overtime pay.

In procedural languages, you would write a `switch` statement, with the different possible cases defined, as follows:

    switch: (employee.type)
    {
      case: Employee
            return employee.salaryToDate;
      case: FullTimeEmployee
            return employee.salaryToDate + employee.bonusToDate
      ...
    }

If you add a new type of employee, then you must update the `switch` statement. In addition, if you modify the data structure, then you need to modify all `switch` statements that use it. In an object-oriented language, such as Java, you can implement a method, `compensationToDate()`, for each subclass of the `Employee` class, if it contains information beyond what is already defined in the `Employee` class. For example, you could implement the `compensationToDate()` method for a non-exempt employee, as follows:

    private float compensationToDate()
    {
      return (super.compensationToDate() + this.overtimeToDate());
    }

For a full-time employee, the `compensationToDate()` method can be implemented as follows:

    private float compensationToDate()
    {
      return (super.compensationToDate() + this.bonusToDate());
    }

This common usage of the method name enables you to call methods of different classes and obtain the required results, without specifying the type of the employee. You do not have to write specific methods to handle full-time employees and part-time employees.

In addition, you could create a `Contractor` class that does not inherit properties from `Employee` and implements a `compensationToDate()` method in it. A program that calculates total payroll to date would iterate over all people on payroll, regardless of whether they were full-time or part-time employees or contractors, and add up the values returned from calling the `compensationToDate()` method on each. You can safely make changes to the individual `compensationToDate()` methods or the classes with the knowledge that callers of the methods will work correctly.

### 1.1.2 Key Features of the Java Language

The Java language provides certain key features that make it ideal for developing server applications. These features include:

- Simplicity

  Java is simpler than most other languages that are used in creating server applications, because of its consistent enforcement of the object model. The large, standard set of class libraries brings powerful tools to Java developers on all platforms.

- Portability

  Java is portable across platforms. It is possible to write platform-dependent code in Java, and it is also simple to write programs that move seamlessly across systems.

  See Also: "The JVM"

- Automatic storage management

  The JVM automatically performs all memory allocation and deallocation while the program is running. Java programmers cannot explicitly allocate memory for new objects or free memory for objects that are no longer referenced. Instead, they depend on the JVM to perform these operations. The process of freeing memory is known as garbage collection.

- Strong typing

  Before you use a variable, you must declare the type of the variable. Strong typing in Java makes it possible to provide a reasonable and safe solution to inter-language calls between Java and PL/SQL applications, and to integrate Java and SQL calls within the same application.

- No pointers

  Although Java retains much of the flavor of C in its syntax, it does not support direct pointers or pointer manipulation. You pass all parameters, except primitive types, by reference and not by value. As a result, the object identity is preserved. Java does not provide low level, direct access to pointers, thereby eliminating any possibility of memory corruption and leaks.

- Exception handling

  Java exceptions are objects. Java requires developers to declare which exceptions can be thrown by methods in any particular class.

- Flexible namespace

  Java defines classes and places them within a hierarchical structure that mirrors the domain namespace of the Internet. You can distribute Java applications and avoid name collisions. Java extensions, such as the Java Naming and Directory Interface (JNDI), provide a framework for multiple name services to be federated. The namespace approach of Java is flexible enough for Oracle to incorporate the concept of a schema for resolving class names in full compliance with the JLS.

- Security

  The design of Java bytecodes and the JVM allow for built-in mechanisms to verify the security of Java binary code. Oracle Database is installed with an instance of Security Manager that, when combined with Oracle Database security, determines who can call any Java methods.

- Standards for connectivity to relational databases

  Java Database Connectivity (JDBC) and SQLJ enable Java code to access and manipulate data in relational databases. Oracle provides drivers that allow vendor-independent, portable Java code to access the relational database.

### 1.1.3 The JVM

As with other high-level computer languages, the Java source compiles to low-level machine instructions. In Java, these instructions are known as bytecodes, because each instruction has a uniform size of one byte. Most other languages, such as C, compile to machine-specific instructions, such as instructions specific to an Intel or HP processor.

When compiled, the Java code gets converted to a standard, platform-independent set of bytecodes, which interacts with a JVM. The JVM is a separate program that is optimized for the specific platform on which you run your Java code. Figure 1-2 illustrates how Java can maintain platform independence. Each platform has a JVM installed that is specific to the operating system. The Java bytecodes get interpreted through the JVM into appropriate platform dependent actions.

Figure 1-2 Java Component Structure

Description of the illustration jvmlayer.gif

When you develop a Java application, you use predefined core class libraries written in the Java language. The Java core class libraries are logically divided into packages that provide commonly-used functionality. Basic language support is provided by the `java.lang` package, I/O support is provided by the `java.io` package, and network access is provided by the `java.net` package. Together, the JVM and core class libraries provide a platform on which Java programmers can develop applications, which will run successfully on any operating system that supports Java. This concept is what drives the "write once, run anywhere" idea of Java.

Figure 1-3 illustrates how Oracle Java applications reside on top of the Java core class libraries, which reside on top of the JVM. Because the Oracle Java support system is located within the database, the JVM interacts with the Oracle Database libraries, instead of directly interacting with the operating system.

Figure 1-3 Oracle Database Java Component Structure

Description of the illustration vmlayercake.gif

Sun Microsystems provides publicly available specifications for both the Java language and the JVM. The JLS defines the syntax and semantics, and the JVM specification defines the necessary low-level actions for the system that runs the application. In addition, Sun Microsystems provides a compatibility test suite for JVM implementors to determine if they have complied with the specifications. This test suite is known as the Java Compatibility Kit (JCK). The Oracle JVM implementation complies fully with JCK. Part of the overall Java strategy is that an openly specified standard, together with a simple way to verify compliance with that standard, allows vendors to offer uniform support for Java across all platforms.

### 1.1.4 Java Class Hierarchy

Java defines classes within a large hierarchy of classes. At the top of the hierarchy is the `Object` class. All classes in Java inherit from the `Object` class at some level, as you walk up through the inheritance chain of superclasses. When we say Class B inherits from Class A, each instance of Class B contains all the fields defined in class B, as well as all the fields defined in Class A. For example, in Figure 1-4, the `FullTimeEmployee` class contains the `id` and `lastName` fields defined in the `Employee` class, because it inherits from the `Employee` class. In addition, the `FullTimeEmployee` class adds another field, `bonus`, which is contained only within `FullTimeEmployee`.

You can call any method on an instance of Class B that was defined in either Class A or Class B. In the example, the `FullTimeEmployee` instance can call methods defined only in the `FullTimeEmployee` class and methods defined in the `Employee` class.

Figure 1-4 Class Hierarchy

Description of the illustration 01intra2.gif

Instances of Class B are substitutable for instances of Class A, which makes inheritance another powerful construct of object-oriented languages for improving code reuse. You can create classes that define behavior and state where it makes sense in the hierarchy, yet make use of preexisting functionality in class libraries.

## 1.2 Using Java in Oracle Database

The only reason that you can write and load Java applications within the database is because it is a safe language with a lot of security features. Java has been developed to prevent anyone from tampering with the operating system that the Java code resides in. Some languages, such as C, can introduce security problems within the database. However, Java, because of its design, is a robust language to be used within the database.

Although the Java language presents many advantages to developers, providing an implementation of a JVM that supports Java server applications in a scalable manner is a challenge. This section discusses the following challenges:

- Java and RDBMS: A Robust Combination

- Multithreading

- Automated Storage Management With Garbage Collection

- Footprint

- Performance

- Dynamic Class Loading

### 1.2.1 Java and RDBMS: A Robust Combination

Oracle Database provides Java applications with a dynamic data-processing engine that supports complex queries and different views of the same data. All client requests are assembled as data queries for immediate processing, and query results are generated on the fly.

Several features make Java ideal for server programming. Java lets you assemble applications using off-the-shelf software components, such as JavaBeans. Its type safety and automatic memory management allow for tight integration with the database. In addition, Java supports the transparent distribution of application components across a network.

Java and Oracle Database support the rapid assembly of component-based, network-centric applications that can evolve gracefully as business needs change. In addition, you can move applications and data stores off the desktop and onto intelligent networks and network-centric servers. More important, you can access those applications and data stores from any client device.

Figure 1-5 shows a traditional two-tier, client/server configuration in which clients call Java stored procedures the same way they call PL/SQL stored procedures. The figure also shows how the Oracle Net Services Connection Manager can combine many network connections into a single database connection. This enables Oracle Database to support a large number of concurrent users.

Figure 1-5 Two-Tier Client/Server Configuration

Description of the illustration two_tier_config.gif

### 1.2.2 Multithreading

Multithreading is one of the key scalability features of the Java language. The Java language and class libraries make it simpler to write multithreaded applications in Java than many other languages, but it is still a daunting task in any language to write reliable, scalable multithreaded code.

As a database server, Oracle Database efficiently schedules work for thousands of users. The Oracle JVM uses the facilities of the database server to concurrently schedule the running of Java application for thousands of users. Although Oracle Database supports Java language-level threads required by the JLS and JCK, scalability will not increase by using threads within the scope of the database. By using the embedded scalability of the database, the need for writing multithreaded Java servers is eliminated.

You should use the facilities of the Oracle Database for scheduling users by writing single-threaded Java applications. The database can schedule processes between each application, and thus, you achieve scalability without having to manage threads. You can still write multithreaded Java applications, but multiple Java threads will not increase the performance of the server.

One complication multithreading creates is the interaction of threads and automated storage management or garbage collection. The garbage collector running in a generic JVM has no knowledge of which Java language threads are running or how the underlying operating system schedules them. The difference between a non-Oracle Database model and an Oracle JVM model is as follows:

- Non-Oracle Database model

  A single user maps to a single Java thread and a single garbage collector manages all garbage from all users. Different techniques typically deal with allocation and collection of objects of varying lifetimes and sizes. The result in a heavily multithreaded application is, at best, dependent upon operating system support for native threads, which can be unreliable and limited in scalability. High levels of scalability for such implementations have not been convincingly demonstrated.

- Oracle JVM model

  Even when thousands of users connect to the server and run the same Java code, each user experiences it as if he is running his own Java code on his own JVM. The responsibility of the Oracle JVM is to make use of operating system processes and threads and the scalable approach of the Oracle Database. As a result of this approach, the garbage collector of the Oracle JVM is more reliable and efficient because it never collects garbage from more than one user at any time.

  See Also: "Threading in Oracle Database"

### 1.2.3 Automated Storage Management With Garbage Collection

Garbage collection is a major function of the automated storage management feature of Java, eliminating the need for Java developers to allocate and free memory explicitly. Consequently, this eliminates a large source of memory leaks that commonly plague C and C++ programs. However, garbage collection contributes to the overhead of program execution speed and footprint.

Garbage collection imposes a challenge to the JVM developer seeking to supply a highly-scalable and fast Java platform. The Oracle JVM meets these challenges in the following ways:

- The Oracle JVM uses the Oracle Database scheduling facilities, which can manage multiple users efficiently.

- Garbage collection is performed consistently for multiple users, because garbage collection is focused on a single user within a single session. The Oracle JVM has an advantage, because the burden and complexity of the job of the memory manager does not increase as the number of users increases. The memory manager performs the allocation and collection of objects within a single session, which typically translates to the activity of a single user.

- The Oracle JVM uses different garbage collection techniques depending on the type of memory used. These techniques provide high efficiency and low overhead.

The two types of memory space are call space and session space.

Memory space | Description
--- | ---
Call space | It is a fast and cheap memory. It primarily exists for the length of a call. Call memory space is divided into new and old segments. All new objects are created within new memory. Objects that have survived several scavenges are moved into old memory.
Session space | It is an expensive, performance-wise memory. It primarily exists for the length of a session. All `static` variables and any objects that exist beyond the lifetime of a call exist here.

Figure 1-6 Garbage Collection

Description of the illustration 02entapa.gif

Garbage collection algorithms within the Oracle JVM adhere to the following rules:

1. New objects are created within new call space.

2. Scavenging occurs at a set interval. Some programmers create objects frequently for only a short duration. These types of objects are created and garbage-collected quickly within the new call space. This is known as scavenging.

3. Any objects that have survived several iterations of scavenging are considered to be objects that can exist for a while. These objects are moved out of new call space into old call space. During the move, they are also compacted. Old call space is scavenged or garbage collected less often and, therefore, provides better performance.

4. At the end of the call, any objects that are to exist beyond the call are moved into session space.

Figure 1-6 illustrates the steps listed in the preceding text. This approach applies sophisticated allocation and collection schemes tuned to the types and lifetimes of objects. For example, new objects are allocated in fast and cheap call memory, designed for quick allocation and access. Objects held in Java `static` variables are migrated to the more precious and expensive session space.

### 1.2.4 Footprint

The footprint of a running Java program is affected by many factors:

- Size of the program

  The size of the program depends on the number of classes and methods and how much code they contain.

- Complexity of the program

  The complexity of the program depends on the number of core class libraries that the Oracle JVM uses as the program runs, as opposed to the program itself.

- Amount of space the JVM uses

  The amount of space the JVM uses depends on the number of objects the JVM allocates, how large these objects are, and how many objects must be retained across calls.

- Ability of the garbage collector and memory manager to deal with the demands of the program running

  This is often nondeterministic. The speed with which objects are allocated and the way they are held on to by other objects influences the importance of this factor.

From a scalability perspective, the key to supporting multiple clients concurrently is a minimum per-user session footprint. The Oracle JVM keeps the per-user session footprint to a minimum by placing all read-only data for users, such as Java bytecodes, in shared memory. Appropriate garbage collection algorithms are applied against call and session memories to maintain a small footprint for the user's session. The Oracle JVM uses the following types of garbage collection algorithms to maintain the user's session memory:

- Generational scavenging for short-lived objects

- Mark and lazy sweep collection for objects that exist for the life of a single call

- Copying collector for long-lived objects, that is, objects that live across calls within a session

### 1.2.5 Performance

The performance of the Oracle JVM is enhanced by implementing a native compiler. The platform-independent Java bytecodes run on top of a JVM, and the JVM interacts with the specific hardware platform. Any time you add levels within software, the performance is degraded. Because Java requires going through an intermediary to interpret the bytecodes, a degree of inefficiency exists for Java applications compared to applications developed using a platform-dependent language, such as C. To address this issue, several JVM suppliers create native compilers. Native compilers translate Java bytecodes into platform-dependent native code, which eliminates the interpreter step and improves performance.

The following table describes two methods for native compilation:

Compiler | Description
--- | ---
Just-In-Time (JIT) Compilation | JIT compilers quickly compile Java bytecodes to platform-specific, or native, machine code during run time. These compilers do not produce an executable to be run on the platform. Instead, they provide platform-dependent code from Java bytecodes that is run directly after it is translated. JIT compilers should be used for Java code that is run frequently and at speeds closer to that of code developed in other languages, such as C.
Ahead-of-Time Compilation | This compilation translates Java bytecodes to platform-independent C code before run time. Then a standard C compiler compiles the C code into an executable for the target platform. This approach is more suitable for Java applications that are modified infrequently. This approach takes advantage of the mature and efficient platform-specific compilation technology found in modern C compilers.

Oracle Database uses Ahead-of-Time compilation to deliver its core Java class libraries, such as JDBC code, in natively compiled form. It is applicable across all the platforms Oracle supports. A JIT approach requires low-level, processor-dependent code to be written and maintained for each platform. You can use this native compilation technology with your own Java code.

As Figure 1-7 shows, natively compiled code runs up to ten times faster than interpreted code. As a result, the more native code your program uses, the faster it runs.

Figure 1-7 Interpreter versus Accelerator

Description of the illustration interpreter_vs_accelerator.gif

See Also: "Natively Compiled Code"

### 1.2.6 Dynamic Class Loading

Another strong feature of Java is dynamic class loading. The class loader loads classes from the disk and places them in the JVM-specific memory structures necessary for interpretation. The class loader locates the classes in `CLASSPATH` and loads them only when they are used while the program is running. This approach, which works well for applets, poses the following problems in a server environment:

Problem | Description | Solution
--- | --- | ---
Predictability | The class loading operation places a severe penalty when the program is run for the first time. A simple program can cause the Oracle JVM to load many core classes to support its needs. A programmer cannot easily predict or determine the number of classes loaded. | The Oracle JVM loads classes dynamically, just as with any other JVM. The same one-time class loading speed hit is encountered. However, because the classes are loaded into shared memory, no other users of those classes will cause the classes to load again, and they will simply use the same preloaded classes.
Reliability | A benefit of dynamic class loading is that it supports program updating. For example, you would update classes on a server, and clients, who download the program and load it dynamically, see the update whenever they next use the program. Server programs tend to emphasize reliability. As a developer, you must know that every client runs a specific program configuration. You do not want clients to inadvertently load some classes that you did not intend them to load. | Oracle Database separates the upload and resolve operation from the class loading operation at run time. You upload Java code you developed to the server using the `loadjava` utility. Instead of using `CLASSPATH`, you specify a resolver at installation time. The resolver is analogous to `CLASSPATH`, but enables you to specify the schemas in which the classes reside. This separation of resolution from class loading ensures that you always know what programs users run. See Also: Chapter 11, "Schema Objects and Oracle JVM Utilities"

## 1.3 The Oracle JVM

The Oracle JVM is a standard, Java-compatible environment that runs any pure Java application. It is compatible with the JLS and the JVM specification laid down by Sun Microsystems. It supports the standard Java binary format and the standard Java APIs. In addition, Oracle Database adheres to standard Java language semantics, including dynamic class loading at run time.

Java in Oracle Database introduces the following terms:

- Session

  A session in the Oracle Database Java environment is identical to the standard Oracle Database usage. A session is typically, although not necessarily, bounded by the time a single user connects to the server. As a user who calls a Java code, you must establish a session in the server.

- Call

  When a user causes a Java code to run within a session, it is termed as a call. A call can be started in the following different ways:

  - A SQL client program runs a Java stored procedure.

  - A trigger runs a Java stored procedure.

  - A PL/SQL program calls a Java code.

  In all the cases defined, a call begins, some combination of Java, SQL, or PL/SQL code is run to completion, and the call ends.

Note: The concept of session and call apply across all uses of Oracle Database.

Unlike other Java environments, the Oracle JVM is embedded within Oracle Database and introduces a number of new concepts. This section discusses some important differences between the Oracle JVM and typical client JVMs based on:

- Process Area

- The main() Method

- The GUI

- The IDE

### 1.3.1 Process Area

In a standard Java environment, you run a Java application through the interpreter by issuing the following command on the command line, where `classname` is the name of the class that you want the JVM to interpret first:

    java classname

This command causes the application to run within a process on your operating system. However, with Oracle JVM, you must load the application into the database, publish the interface, and then run the application within a database session.

See Also: Chapter 2, "Java Applications on Oracle Database" for information on loading, publishing, and running Java applications

### 1.3.2 The main() Method

Client-based Java applications declare a single, top-level method, `public static void main(String args[])`. This method defines the profile of an application. As with applets, server-based applications have no such inner loop. Instead, they are driven by logically independent clients.

Each client begins a session, calls its server-side logic modules through top-level entry points, and eventually ends the session. The server environment hides the process of management of sessions, networks, and other shared resources from hosted Java programs.

### 1.3.3 The GUI

A server cannot provide GUIs, but it can provide the logic that drives them. The Oracle JVM supports only the headless mode of the Java Abstract Window Toolkit (AWT). All Java AWT classes are available within the server environment and your programs can use the Java AWT functionality, as long as they do not attempt to materialize a GUI on the server.

See Also: "User Interfaces on the Server"

### 1.3.4 The IDE

The Oracle JVM is oriented to Java application deployment, and not development. You can write and test applications on any preferred integrated development environment (IDE), such as Oracle JDeveloper, and then deploy them within the database for the clients to access and run them.

See Also: "Development Tools"

The binary compatibility of Java enables you to work on any IDE and then upload the Java class files to the server. You need not move your Java source files to the database. Instead, you can use powerful client-side IDEs to maintain Java applications that are deployed on the server.

## 1.4 Main Components of the Oracle JVM

This section briefly describes the main components of the Oracle JVM and some of the facilities they provide.

The Oracle JVM is a complete, Java2-compliant environment for running Java applications. It runs in the same process space and address space as the database kernel by sharing its memory heaps and directly accessing its relational data. This design optimizes memory use and increases throughput.

The Oracle JVM provides a run-time environment for Java objects. It fully supports Java data structures, method dispatch, exception handling, and language-level threads. It also supports all the core Java class libraries, including `java.lang`, `java.io`, `java.net`, `java.math`, and `java.util`. Figure 1-8 shows the main components of the Oracle JVM.

Figure 1-8 Main Components of the Oracle JVM

Description of the illustration jvm_components.gif

The Oracle JVM embeds the standard Java namespace in the database schemas. This feature lets Java programs access Java objects stored in the Oracle Database and application servers across the enterprise.

In addition, the Oracle JVM is tightly integrated with the scalable, shared memory architecture of the database. Java programs use call, session, and object lifetimes efficiently without user intervention. As a result, the Oracle JVM and middle-tier Java business objects can be scaled, even when they have session-long state.

The following sections provide an overview of some of the components of the Oracle JVM and the JDBC driver and the SQLJ translator:

- Library Manager

- Compiler

- Interpreter

- Class Loader

- Verifier

- Server-Side JDBC Internal Driver

- Server-Side SQLJ Translator

See Also: "Automated Storage Management With Garbage Collection" and "Performance"

### 1.4.1 Library Manager

To store Java classes in the Oracle Database, you use the `loadjava` command-line utility, which uses the SQL `CREATE JAVA` statements to do its work. When called by the `CREATE JAVA {SOURCE | CLASS | RESOURCE}` statement, the library manager loads Java source, class, or resource files into the database. These Java schema objects are not accessed directly, and only the Oracle JVM uses them.

### 1.4.2 Com piler

The Oracle JVM includes a standard Java compiler. When the `CREATE JAVA SOURCE` statement is run, it translates Java source files into architecture-neutral, one-byte instructions known as bytecodes. Each bytecode consists of an opcode followed by its operands. The resulting Java class files, which conform fully to the Java standard, are submitted to the interpreter at run time.

See Also: "Natively Compiled Code"

### 1.4.3 Interpre ter

To run Java programs, the Oracle JVM includes a standard Java2 bytecode interpreter. The interpreter and the associated Java run-time system run standard Java class files. The run-time system supports native methods and call-in and call-out from the host environment.

Note: You can also compile your Java code to improve performance. The Oracle JVM uses natively compiled versions of the core Java class libraries, SQLJ translator, and JDBC drivers.

### 1.4.4 Class Loader

In response to requests from the run-time system, the Java class loader locates, loads, and initializes Java classes stored in the database. The class loader reads the class and generates the data structures needed to run it. Immutable data and metadata are loaded into initialize-once shared memory. As a result, less memory is required for each session. The class loader attempts to resolve external references when necessary. In addition, if the source files are available, then the class loader calls the Java compiler automatically when Java class files must be recompiled.

### 1.4.5 Verifier

Java class files are fully portable and conform to a well-defined format. The verifier prevents the inadvertent use of spoofed Java class files, which might alter program flow or violate access restrictions. Oracle security and Java security work with the verifier to protect your applications and data.

### 1.4.6 Server-Side JDBC Internal Driver

JDBC is a standard and defines a set of Java classes providing vendor-independent access to relational data. Specified by Sun Microsystems and modeled after ODBC and the X/Open SQL Call Level Interface (CLI), the JDBC classes provide standard features, such as simultaneous connections to several databases, transaction management, simple queries, calls to stored procedures, and streaming access to `LONG` column data.

Using low-level entry points, a specially tuned JDBC driver runs directly inside the Oracle Database, providing fast access to Oracle data from Java stored procedures. The server-side JDBC internal driver complies fully with the standard JDBC specification. Tightly integrated with the database, the JDBC driver supports Oracle-specific data types, globalization character sets, and stored procedures. In addition, the client-side and server-side JDBC APIs are the same, which makes it easy to partition applications.

### 1.4.7 Server-Side SQLJ Translator

SQLJ enables you to embed SQL statements in Java programs. It is more concise than JDBC and more responsive to static analysis and type checking. The SQLJ preprocessor, which itself is a Java program, takes as input a Java source file in which SQLJ clauses are embedded. Then, it translates the SQLJ clauses into Java class definitions that implement the specified SQL statements. The Java type system ensures that objects of those classes are called with the correct arguments.

A highly optimized SQLJ translator runs directly inside the database, where it provides run-time access to Oracle data using the server-side internal JDBC driver. SQLJ forms can include queries, data manipulation language (DML) statements, data definition language (DDL) statements, transaction control statements, and calls to stored procedures. The client-side and server-side SQLJ APIs are identical, making it easy to partition applications.

## 1.5 Java Application Strategy of Oracle

Oracle provides enterprise application developers an end-to-end Java solution for creating, deploying, and managing Java applications. The total solution consists of client-side and server-side programmatic interfaces, tools to support Java development, and a JVM integrated with the Oracle Database. All these products are fully compatible with Java standards. This section covers the following topics:

- Java in Database Application Development

- Java Programming Environment

- Java Stored Procedures

- PL/SQL Integration and Oracle RDBMS Functionality

- Development Tools

### 1.5.1 Java in Database Application Development

The most important features of Java in database application development are:

- Providing flexible partitioning of Java2 Platform, Standard Edition (J2SE) applications for symmetric data access at the JDBC and SQLJ level.

- Bridging SQL and the Java2 Platform, Enterprise Edition (J2EE) world by:

  - Calling out Web components, such as JSP and servlet

  - Calling out Enterprise JavaBean (EJB) components

  - Bridging SQL and Web Services

    - Calling out Web Services

  - Using Oracle JVM as ERP Integration Hub

  - Invalidating cache

### 1.5.2 Java Programming Environment

In addition to the Oracle JVM, the Java programming environment provides:

- Java stored procedures as the Java equivalent and companion for PL/SQL. Java stored procedures are tightly integrated with PL/SQL. You can call Java stored procedures from PL/SQL packages and PL/SQL procedures from Java stored procedures.

- The JDBC and SQLJ programming interfaces for accessing SQL data.

- Tools and scripts that assist in developing, loading, and managing classes.

The following table helps you decide when to use which Java API:

Type of functionality you need | Java API to use
--- | ---
To have a Java procedure called from SQL, such as a trigger. | Java stored procedures
To call a static, simple SQL statement from a known table with known column names from a Java object. | SQLJ
To call dynamic, complex SQL statements from a Java object. | JDBC

### 1.5.3 Java Stored Procedures

Java stored procedures are Java programs written and deployed on a server and run from the server, exactly like a PL/SQL stored procedure. You invoke it directly with products like SQL*Plus, or indirectly with a trigger. You can access it from any Oracle Net client, such as OCI and PRO*, or JDBC or SQLJ.

See Also: Chapter 5, "Developing Java Stored Procedures"

In addition, you can use Java to develop powerful, server-side programs, which can be independent of PL/SQL. Oracle Database provides a complete implementation of the standard Java programming language and a fully-compliant JVM.

In Oracle Database, the lifetime of a Java stored procedure session is identical to the database session in which it is embedded. Any state represented in Java transparently persists for the lifetime of the database session, simplifying the process of writing stored procedures, triggers, and methods for Oracle abstract data types.

### 1.5.4 PL/SQL Integration and Oracle RDBMS Functionality

You can call existing PL/SQL programs from Java and Java programs from PL/SQL. This solution protects and leverages your PL/SQL and Java code and opens up the advantages and opportunities of Java-based Internet computing.

Oracle Database offers two different Java APIs for accessing SQL data, JDBC and SQLJ. Both these APIs are available on the client and the server. As a result, you can deploy your applications on the client and server, without modifying the code.

The following topics introduce the Java APIs and the JPublisher tool provided by Oracle Database:

- JDBC Drivers

- SQLJ

- JPublisher

#### 1.5.4.1 JDBC Drivers

JDBC is a database access protocol that enables you to connect to a database and run SQL statements and queries to the database. The core Java class libraries provide only one JDBC API, `java.sql`. However, JDBC is designed to enable vendors to supply drivers that offer the necessary specialization for a particular database. Oracle provides the following distinct JDBC drivers:

Driver | Description
--- | ---
JDBC Thin driver | You can use the JDBC Thin driver to write pure Java applications and applets that access Oracle SQL data. The JDBC Thin driver is especially well-suited for Web-based applications and applets, because you can dynamically download it from a Web page, similar to any other Java applet.
JDBC OCI driver | The JDBC OCI driver accesses Oracle-specific native code, that is, non-Java code, and libraries on the client or middle tier, providing performance boost compared to the JDBC Thin driver, at the cost of significantly larger size and client-side installation.
JDBC server-side internal driver | Oracle Database uses the server-side internal driver when the Java code runs on the server. It allows Java applications running in the Oracle JVM on the server to access locally defined data, that is, data on the same system and in the same process, with JDBC. It provides a performance boost, because of its ability to use the underlying Oracle RDBMS libraries directly, without the overhead of an intervening network connection between the Java code and SQL data. By supporting the same Java-SQL interface on the server, Oracle Database does not require you to rework code when deploying it.

See Also: "Utilizing SQLJ and JDBC for Querying the Database" Oracle Database JDBC Developer's Guide and Reference

#### 1.5.4.2 SQLJ

Oracle has worked with other vendors, including IBM, Tandem, Sybase, and Sun Microsystems, to develop a standard way to embed SQL statements in Java programs called SQLJ. This work has resulted in a new standard, ANSI x.3.135.10-1998, for a simpler and more highly productive programming API than JDBC. A user writes applications to this higher-level API and then uses a preprocessor to translate the program to standard Java source with JDBC calls. At run time, the program can communicate with multi-vendor databases using standard JDBC drivers.

SQLJ provides a simple, but powerful, way to develop both client-side and middle-tier applications that access databases from Java. You can use SQLJ in stored procedures, triggers, and methods within the Oracle Database 10g environment. In addition, you can combine SQLJ programs with JDBC.

The SQLJ translator is a Java program that translates embedded SQL in Java source code to pure JDBC-based Java code. Because Oracle Database 10g provides a complete Java environment, you cannot compile SQLJ programs on a client that will run on the server. Instead, you can compile them directly on the server. The adherence of Oracle Database to the Internet standards enables you to choose the development style as per your requirements.

See Also: "Utilizing SQLJ and JDBC for Querying the Database" Oracle Database SQLJ Developer's Guide and Reference

#### 1.5.4.3 JPublisher

JPublisher provides a simple and convenient tool to create Java programs that access existing Oracle relational database tables.

See Also: Oracle Database JPublisher User's Guide

### 1.5.5 Development Tools

The introduction of Java in Oracle Database enables you to use several Java IDEs. The adherence of Oracle Database to the Java standards and specifications and the open Internet standards and protocols ensures that your Java programs work successfully, when you deploy them on Oracle Database. Oracle provides many tools or utilities that are written in Java making development and deployment of Java server applications easier. Oracle JDeveloper, a Java IDE provided by Oracle, has many features designed specifically to make deployment of Java stored procedures and EJBs easier. You can download JDeveloper from: `http://www.oracle.com/technology/software/products/jdev/index.html`

## 1.6 Desupport of J2EE Technologies in the Oracle Database

With the introduction of Oracle Application Server Containers for J2EE (OC4J), a new, light-weight, easy-to-use, fast, and certified J2EE container, Oracle began the desupport of the J2EE and Common Object Request Broker Architecture (CORBA) stacks from the database, starting with Oracle9i Database release 2. However, the database-embedded Oracle JVM is still present and will continue to be enhanced to provide J2SE features, Java stored procedures, and JDBC and SQLJ in the database.

As of Oracle9i Database release 2 (9.2.0), Oracle no longer supports the following technologies in the database:

- The J2EE stack, consisting of:

  - EJB container

  - JavaServer Pages (JSP) container

  - Oracle9i Servlet Engine (OSE)

- The embedded CORBA framework, based on Visibroker for Java

Customers will no longer be able to deploy servlets, JSP pages, EJBs, and CORBA objects in Oracle databases. Oracle9i Database release 1 (9.0.1) will be the last database release to support the J2EE and CORBA stack. Oracle is encouraging customers to migrate existing J2EE applications running in the database to OC4J now.

## 1.7 Memory Model for Dedicated Mode Sessions

In Oracle Database 10g, the Oracle JVM has a new memory model for sessions that connect to the database through a dedicated server. Since a session using a dedicated server is guaranteed to use the same process for every database call, the Process Global Area (PGA) is used for session specific memory and object allocations. This means that some of the objects and resources that used to be reclaimed at the end of each call can now live across calls. In particular, resources specific to a particular operating system, such as threads and open files, now are no longer cleaned up at the end of each database call.

For sessions that use shared servers, the restrictions across calls that applied in previous releases are still present. The reason is that a session that uses a shared server is not guaranteed to connect to the same process on a subsequent database call, and hence the session-specific memory and objects that need to live across calls are saved in the System Global Area (SGA). This means that process-specific resources, such as threads, open files and sockets must be cleaned up at the end of each call, and hence will not be available for the next call.

## 1.8 What's New in this Release?

The following sections describe the additions to this release:

- Upgrading to J2SE 1.4.2

- Auditing SQL Statements Related to Java Schema Objects

- The PGA_AGGREGATE_TARGET parameter

### 1.8.1 Upgrading to J2SE 1.4.2

In this release, the system classes are upgraded from J2SE 1.4.1 to J2SE 1.4.2. Sun Microsystems publishes the list of incompatibilities between J2SE 1.4.2 and previous versions at the following Web site:

`http://java.sun.com/j2se/1.4.2/compatibility.html`

### 1.8.2 Auditing SQL Statements Related to Java Schema Objects

Oracle Database 10g release 2 (10.2) provides support for auditing DDL statements related to Java schema objects. That is, you can audit the SQL statements used to create, alter, and drop the Java source, class, and resource schema objects.

See Also: "Auditing" for further information

### 1.8.3 The PGA_AGGREGATE_TARGET parameter

The `PGA_AGGREGATE_TARGET` parameter is a database parameter that can be set in the `init.ora` file. When the PGA usage is greater than the desired value set using this parameter, the JVM performs additional memory management actions at the end of call to reduce PGA usage. Specifically, the live contents of the Java heap are copied and compacted to a new area and the existing Java heap is freed. The new area becomes the Java heap for subsequent calls. This step is intended to compact Java heap down to the minimal necessary size between database calls. However, this step does not run if there are live Java threads at the end of the call.

See Also: Oracle Database Performance Tuning Guide

Notes: The "Setting PGA_AGGREGATE_TARGET Initially" section in Oracle Database Performance Tuning Guide does not take into account the memory usage of Java applications. The memory usage of Java code in the server is not as predictable as that of SQL. Therefore, it is important to monitor and tune Automatic PGA Memory Management.